home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 050 / madtrb1.arc / TSIPP2.DOC < prev   
Text File  |  1986-03-04  |  29KB  |  702 lines
  1.  
  2.  
  3.                                   Page 20
  4.  
  5.  
  6.  
  7.  
  8. X. CHILD PROGRAM EXECUTION
  9.  
  10.  
  11. The include subprogram file "Execute.Inc" contains routines that allow you to
  12. run other programs directly from Turbo Pascal, get the return codes when those
  13. programs terminate, and be able to temporarily exit your Turbo program to issue
  14. DOS commands.
  15.  
  16. You could, for example, use these routines within this include file to execute
  17. a child program, perhaps written in Fortran.  The user would be totally unaware
  18. that control had been passed to a different program.  Once the child program
  19. terminates, control would then be passed back to the parent program,
  20. specifically to the next line of Pascal code.  Thus one could write a Turbo
  21. Pascal shell program to execute other programs, thereby preventing the user
  22. from having to deal with DOS.
  23.  
  24. The Exec calls in "Execute.Inc" (SubProcess, SubProcessViaCOMMAND, ShellToDOS,
  25. ExecuteChildProgram) will not work unless you restrict Turbo's allocated heap.
  26. To do this, lower "mAximum dynamic free memory" on the compiler Options menu to
  27. a reasonable value.  What a reasonable value is depends on your program's use
  28. of the heap and the stack, and must be determined by you.  The value 1000 (64k)
  29. is a fairly good value to start off with for a large program like the input
  30. pre-processor.  Then try reducing, if possible, that value as your program
  31. development nears completion.
  32.  
  33. The Exec calls CANNOT be called from within the interactive Turbo compiler
  34. system.  They can only be called from .COM or .CHN files running outside of the
  35. Turbo environment.
  36.  
  37.  
  38.  
  39.  
  40. XI. DESCRIPTION OF SCREEN TEMPLATES
  41.  
  42.  
  43. The screen templates are the key to the versatility of this the pre-processor.
  44. It is by altering these templates you then alter how the screen pages will
  45. appear to the user.  For example, you may have four different application core
  46. programs you have written and each program requires a unique set of inputs from
  47. the user.  All you do is alter the screen templates for each of the four
  48. programs with the proper screen template generators, while using the same input
  49. pre-processor subprograms to control the interaction between the user and the
  50. four application programs.
  51.  
  52.  
  53.  
  54.                                   Page 21
  55.  
  56.  
  57.  
  58.  
  59. A screen template is simply a file containing information about the prompts
  60. (or descriptors) to be displayed when a particular screen page is shown.
  61. The screen template file is a series of records where each record describes one
  62. descriptor (or prompt).
  63.  
  64. Thus the input pre-processor then uses these screen templates, for example, to
  65. determine which descriptor to highlight when the user curses downward.  The
  66. pre-processor also uses the screen template to determine what character types
  67. are allowed for a particular entry.  And by simply altering the prompt locators
  68. you redefine where a particular prompt is to be located on the screen.
  69.  
  70. There are three template form sheets included in this toolkit.  They are
  71. "G_I_Tpl.Frm", "Menu_Tpl.Frm", and "S_I_Tpl.Frm".  These forms will aid you in
  72. designing and filling out your screen templates.  I recommend that you set
  73. your printer to print in compressed mode before printing out these forms since
  74. they are 125 columns wide.  Then fill out the template forms according to the
  75. directions included with each of forms.
  76.  
  77.  
  78. A. GENERAL INPUT SCREEN TEMPLATE
  79.  
  80. Below is an example general input screen template record.
  81.  
  82.  
  83.                  EXAMPLE GENERAL INPUT SCREEN TEMPLATE RECORD
  84.  
  85.                                                                               /
  86.     |-------|-------|-------|-------|-------|-------|-------|-------|-------|/
  87.     |Record |Prompt |Prompt |Input  |Input  |Input  |Input  |Return |Up     /
  88.     |Number |Column |Row    |Column |Row    |Length |Data   |Key    |Key   /
  89.     |       |       |       |       |       |       |Type   |Pointer|Point/
  90.     |-------|-------|-------|-------|-------|-------|-------|-------|----/
  91.     |  17   |   5   |  19   |  32   |  19   |   5   |  4    |  18   |   /
  92.     |-------|-------|-------|-------|-------|-------|-------|-------|--/
  93.                                                                       /
  94.  
  95.            /
  96.           /-|-------|-------|-------|-------|------------------------------|
  97.          /  |Up     |Down   |Left   |Right  |Prompt                        |
  98.         /   |Key    |Key    |Key    |Key    |                              |
  99.        /nter|Pointer|Pointer|Pointer|Pointer|                              |
  100.       /-----|-------|-------|-------|-------|------------------------------|
  101.      /      |  15   |  19   |   0   |  18   |Beam Spacing (ft)             |
  102.     /-------|-------|-------|-------|-------|------------------------------|
  103.    /
  104.  
  105.  
  106.  
  107.                                   Page 22
  108.  
  109.  
  110.  
  111.  
  112. Description of the previous general input template record fields:
  113.  
  114.  
  115.      Record Number
  116.      -------------
  117.           Record Number is not an actual field in the template file, but is
  118.           present in the previous example screen template record to help you
  119.           see that we are looking at record 17.
  120.  
  121.  
  122.      Prompt Column and Prompt Row
  123.      ----------------------------
  124.           Prompt Column and Prompt Row describe the X,Y location on the screen
  125.           where the prompt "Beam Spacing (ft)" will be displayed (note that the
  126.           screen is 80 columns wide and 25 rows high, the upper left corner of
  127.           the screen is column 1, row 1 ).  For the previous example screen
  128.           template record the general input page subprogram will display the
  129.           prompt "Beam Spacing (ft)" at column 5, row 19.
  130.  
  131.  
  132.      Input Column and Input Row
  133.      --------------------------
  134.           Input Column and Input Row describes the X,Y location on the screen
  135.           of the start of the reverse video input block.  The reverse video
  136.           input block is where the user enters his input onto the screen.  For
  137.           the previous example screen template record the general input page
  138.           subprogram will display the reverse video input block starting at
  139.           column 32, row 19.
  140.  
  141.  
  142.      Input Length
  143.      ------------
  144.           Input Length describes how long the reverse video input block is
  145.           (number of columns long).  The general input page subprogram makes
  146.           certain that the user's data entry length does not exceed this
  147.           maximum allowed length as the data entry is entered.  For the
  148.           previous example screen template record the reverse video input block
  149.           is five characters long.
  150.  
  151.  
  152.  
  153.                                   Page 23
  154.  
  155.  
  156.  
  157.  
  158.      Input Data Type
  159.      ---------------
  160.           Input Data Type is used to define what type of characters the user is
  161.           allowed to enter for a particular entry.  The general input
  162.           subprogram then checks as the user enters characters from the
  163.           keyboard that the characters are of the type allowed.  For example,
  164.           if only a positive integer is allowed, only that data type will be
  165.           allowed to be entered from the keyboard.  All other characters will
  166.           be discarded with an error sounded also.  A list of different input
  167.           data types that the general input subprogram can check for
  168.           follows:
  169.  
  170.  
  171.               Input
  172.               Data
  173.               Type
  174.               Value       Description of Input Data Type
  175.               -----       -------------------------------------------
  176.                 1         Positive Integer ( including zero )
  177.                 2         Negative Integer ( including zero )
  178.                 3         Integer
  179.                 4         Positive Real ( including zero )
  180.                 5         Negative Real ( including zero )
  181.                 6         Real
  182.                 7         Data File Name Characters
  183.                 8         Disk Drive and Subdirectory Path Characters
  184.                 9         General Characters
  185.  
  186.  
  187.      Return Key Pointer
  188.      ------------------
  189.           Return Key Pointer identifies for the general input page subprogram
  190.           the record of the prompt to be highlighted when the user enters a
  191.           carriage return while at this prompt.  In the previous example screen
  192.           template record, when the user is at the highlighted prompt "Beam
  193.           Spacing (ft)" and the user enters a carriage return, the prompt of
  194.           record 18 would then be highlighted.  The previous prompt "Beam
  195.           Spacing (ft)" would return to a non-highlighted color.  Thus the
  196.           highlighted prompt is used to inform the user at what prompt he is
  197.           at.
  198.  
  199.  
  200.  
  201.                                   Page 24
  202.  
  203.  
  204.  
  205.  
  206.      Up Key Pointer, Down Key Pointer, Left Key Pointer, and Right Key Pointer
  207.      -------------------------------------------------------------------------
  208.           Up Key Pointer, Down Key Pointer, Left Key Pointer, and Right Key
  209.           Pointer identify for the general input page subprogram the particular
  210.           record of a prompt to be highlighted when the user enters that
  211.           particular keystroke while at this prompt.  Note that a zero in a
  212.           direction field indicates that a particular keystroke is not allowed.
  213.           In the previous example, when the user is at that prompt "Beam
  214.           Spacing (ft)" he cannot curse to the left.  The general input page
  215.           subprogram will ignore this keystroke and sound an error.
  216.  
  217.  
  218.      Prompt
  219.      ------
  220.           Prompt is a string field in which the particular prompt is stored.
  221.           What is entered in this field will be what the general input page
  222.           subprogram will display at Prompt Column, Prompt Row.
  223.  
  224.  
  225. B. MENU SCREEN TEMPLATE RECORDS
  226.  
  227. A similar screen template to that of the general input screens are used for
  228. each menu screen.  The menu subprogram then abides by the menu templates you
  229. define in controlling the display and handling of the menus.  The following
  230. record fields are contained in the menu screen template:
  231.  
  232.  
  233.           Prompt Column
  234.           Prompt Row
  235.           Return Key Pointer
  236.           Up Key Pointer
  237.           Down Key Pointer
  238.           Left Key Pointer
  239.           Right Key Pointer
  240.           Prompt
  241.  
  242.  
  243.  
  244.                                   Page 25
  245.  
  246.  
  247.  
  248.  
  249. C. SCROLLING INPUT COLUMN HEADING TEMPLATES
  250.  
  251. The scrolling input screens use a very simplified template.  Basically, only
  252. the column heading descriptors (or prompts) are stored in the screen template,
  253. along with the particular input data type allowed for each column.  The input
  254. pre-processor is setup to display only three rows of text for each column
  255. descriptor.
  256.  
  257. Below is an example of four scrolling input screens with their column headings
  258. similar to that used in the example application of the input pre-processor.
  259. Notice each column heading has only three rows of text, and each column field
  260. width is 9 columns.
  261.  
  262.  
  263.             EXAMPLE SCROLLING INPUT COLUMN HEADING TEMPLATE RECORD
  264.  
  265.  
  266.    |-----------|---------|---------|---------|---------|---------|---------|
  267.    |           |Column 1 |Column 2 |Column 3 |Column 4 |Column 5 |Column 6 |
  268.    |-----------|=========|=========|=========|=========|=========|=========|
  269.    |S_I_Page1 ||         |         |         |         |         |         |
  270.    |Prompt 1  ||Load     |X1       |Load     |X2       |Load     |         |
  271.    |Prompt 2  ||Number   |Position |         |Position |Width    |         |
  272.    |Prompt 3  ||         |(ft)     |(kip/ft) |(ft)     |(ft)     |         |
  273.    |Data Type ||         |4        |4        |4        |4        |         |
  274.    |----------||---------|---------|---------|---------|---------|---------|
  275.    |S_I_Page2 ||         |         |         |         |         |         |
  276.    |Prompt 1  ||Load     |X        |Load     |         |         |         |
  277.    |Prompt 2  ||Number   |Position |at X     |         |         |         |
  278.    |Prompt 3  ||         |(ft)     |(kip)    |         |         |         |
  279.    |Data Type ||         |4        |4        |         |         |         |
  280.    |----------||---------|---------|---------|---------|---------|---------|
  281.    |S_I_Page3 ||         |         |         |         |         |         |
  282.    |Prompt 1  ||Load     |X1       |Load     |X2       |Load     |Load     |
  283.    |Prompt 2  ||Number   |Position |at X1    |Position |at X2    |Width    |
  284.    |Prompt 3  ||         |(ft)     |(kip/ft) |(ft)     |(kip/ft) |(ft)     |
  285.    |Data Type ||         |4        |4        |4        |4        |4        |
  286.    |----------||---------|---------|---------|---------|---------|---------|
  287.    |S_I_Page4 ||         |         |         |         |         |         |
  288.    |Prompt 1  ||Load     |X        |Applied  |         |         |         |
  289.    |Prompt 2  ||Number   |Position |Moment   |         |         |         |
  290.    |Prompt 3  ||         |(ft)     |(ft-kip) |         |         |         |
  291.    |Data Type ||         |4        |4        |         |         |         |
  292.    |----------||---------|---------|---------|---------|---------|---------|
  293.  
  294.  
  295.  
  296.                                   Page 26
  297.  
  298.  
  299.  
  300.  
  301. Observe that some of the scrolling input screens have less column headings (and
  302. less columns) than others.  Those particular column headings were simply left
  303. blank when the scrolling input screen template was defined by the scrolling
  304. input column heading template generator.
  305.  
  306. Below is a list of data types that the scrolling input subprogram can check
  307. for.
  308.  
  309.  
  310.               Input
  311.               Data
  312.               Type
  313.               Value       Description of Input Data Type
  314.               -----       -------------------------------------------
  315.                 1         Positive Integer ( including zero )
  316.                 2         Negative Integer ( including zero )
  317.                 3         Integer
  318.                 4         Positive Real ( including zero )
  319.                 5         Negative Real ( including zero )
  320.                 6         Real
  321.                 7         Data File Name Characters
  322.                 8         Disk Drive and Subdirectory Path Characters
  323.                 9         General Characters
  324.  
  325.  
  326.  
  327.  
  328. XII. SCREEN TEMPLATE GENERATORS
  329.  
  330.  
  331. Before using the template generators, print out the template form sheets that
  332. you require.  They are "G_I_Tpl.Frm", "Menu_Tpl.Frm", and "S_I_Tpl.Frm".  I
  333. recommend that you set your printer to print in compressed mode since these
  334. forms are 125 columns wide.  Then fill out the template forms according to the
  335. directions included with the forms.
  336.  
  337. There are three template generators associated with this toolkit.  Below is
  338. a list of the generator names and the templates they generate.
  339.  
  340.  
  341.           Template
  342.           Generator            Template Generated
  343.           ------------         ----------------------------------------
  344.           G_I_Tpl.Gen          General Input Screen Templates
  345.           Menu_Tpl.Gen         Menu Screen Templates
  346.           S_I_Tpl.Gen          Scrolling Input Column Heading Templates
  347.  
  348.  
  349.  
  350.                                   Page 27
  351.  
  352.  
  353.  
  354.  
  355. The template generators are used in entering the parameters and descriptors (or
  356. prompts) into template files for the various subprograms to use.
  357.  
  358. For example, the general input screen template generator "G_I_Tpl.Gen" provides
  359. a method of entering the input prompt parameters for the general input screen
  360. template storing them in a template file so that it can be read and used by the
  361. general input page subprogram.
  362.  
  363. The template generators are rather crude programs when you actually get around
  364. to using them.  They must be "hard-wired" by you for them to work in generating
  365. the proper screen templates for your application.  I never bothered to make
  366. them any easier to use since they are generally only used once or twice during
  367. actual template development.  Perhaps someday I will use the input pre-
  368. processor toolkit to make the template generators more user friendly.  Then it
  369. will be sort of like who came first--the chicken or the egg!
  370.  
  371. When using the template generators you will have to "hard-wire" the following
  372. constants to make the template generators work for your application:
  373.  
  374.  
  375.      G_I_Tpl.Gen -- General Input Screen Template Generator
  376.      ------------------------------------------------------
  377.  
  378.          TEMPLATE_RECORD_LIMIT      -- The number of records in the new screen
  379.                                        template.
  380.          TEMPLATE_FILE_NAME         -- The name of the file you want the screen
  381.                                        template to be written to.
  382.  
  383.  
  384.      Menu_Tpl.Gen -- Menu Screen Template Generator
  385.      ----------------------------------------------
  386.  
  387.          MENU_RECORD_LIMIT          -- The number of records in the new screen
  388.                                        template.
  389.          MENU_FILE_NAME             -- The name of the file you want the screen
  390.                                        template to be written to.
  391.  
  392.  
  393.  
  394.                                   Page 28
  395.  
  396.  
  397.  
  398.  
  399.      S_I_Tpl.Gen -- Scrolling Input Column Heading Template Generator
  400.      ----------------------------------------------------------------
  401.  
  402.          MAX_NUM_OF_S_I_PROMPT_COLS -- The maximum number of column headings
  403.                                        on any particular scrolling input
  404.                                        page.
  405.          MAX_NUM_OF_S_I_PAGES       -- The number of scrolling input pages
  406.                                        you want included in the scrolling
  407.                                        input column heading template you are
  408.                                        generating.
  409.          FILE_NAME                  -- The name of the file you want the screen
  410.                                        template to be written to.
  411.  
  412.  
  413. Both "G_I_Tpl.Gen" and "Menu_Tpl.Gen" generate one screen template file at a
  414. time.  Thus each screen template is for only one physical screen page.
  415. "S_I_Tpl.Gen" also generates only one template file at a time, but the template
  416. it generates supports as many physical scrolling input pages that you want your
  417. particular application program to have.
  418.  
  419.  
  420.  
  421.  
  422. XIII. PRE-PROCESSOR ALTERATIONS
  423.  
  424.  
  425. I have listed below the changes that you may need to make to your particular
  426. application of the input pre-processor.
  427.  
  428.  
  429. A. DISPLAY SUBPROGRAM "Display.Inc"
  430.  
  431.       This subprogram is linked with scrolling input subprogram.  If you are
  432.       not using the scrolling input subprogram, then you do not need this
  433.       display subprogram.
  434.  
  435.       If you plan on using the scrolling input subprogram and this subprogram,
  436.       you will have to tailor this display subprogram for your particular
  437.       application.  You may perhaps want to display a graph, bar chart, etc.
  438.       as the user is entering his data into the scrolling input pages.
  439.  
  440.  
  441.  
  442.                                   Page 29
  443.  
  444.  
  445.  
  446.  
  447. B. ERROR CHECKING SUBPROGRAM "Error.Inc"
  448.  
  449. You may need to alter the following procedures for your particular
  450. implementation of the pre-processor:
  451.  
  452.       G_I_ErrorCheckingModule
  453.       S_I_ErrorCheckingModule
  454.  
  455.  
  456. C. EXECUTE SUBPROGRAM "Execute.Inc"
  457.  
  458.       No changes required.
  459.  
  460.       You will need to lower the maximum free dynamic memory at compile time
  461.       for routines to work.  See section describing executing child programs
  462.       for more information.
  463.  
  464.  
  465. D. FILE I/O SUBPROGRAM "File.Inc"
  466.  
  467. You may need to alter the following procedures for your particular
  468. implementation of the pre-processor:
  469.  
  470.       ReadInputDataFile
  471.       WriteInputDataFile
  472.  
  473.  
  474. E. GENERAL INPUT SUBPROGRAM "G_Input.Inc"
  475.  
  476. You may need to alter the following procedures for your particular
  477. implementation of the pre-processor:
  478.  
  479.       HighlightSpecial_G_I_Prompts
  480.       Draw_G_I_PagesModule
  481.       Special_G_I_CharEntryModule
  482.       Escape
  483.       PageUp
  484.       PageDown
  485.       ReadKeyboard
  486.  
  487.  
  488.  
  489.                                   Page 30
  490.  
  491.  
  492.  
  493.  
  494. F. INITIALIZATION SUBPROGRAM "Init.Inc"
  495.  
  496.       No changes needed.
  497.  
  498.       You will need to remove some of the initialization procedure calls in
  499.       the procedure InitModule if you are not using all of the toolkit's
  500.       subprograms.
  501.  
  502.  
  503. G. MAIN SUBPROGRAM "Tsipp.Pas"
  504.  
  505. You may need to alter the following constants for your particular
  506. implementation of the pre-processor:
  507.  
  508.       MAX_NUM_OF_G_I_PAGES          -- The number of general input pages (or
  509.                                        templates) your particular application
  510.                                        has.
  511.  
  512.       MAX_NUM_OF_MENU_PAGES         -- The number of menu pages (or templates)
  513.                                        your particular application has.
  514.  
  515.       MAX_NUM_OF_S_I_PAGES          -- The number of scrolling input pages
  516.                                        your particular application has.
  517.  
  518.       MAX_NUM_OF_TEXT_SCREENS       -- The number of temporary text screens
  519.                                        that you want to store in the heap, as
  520.                                        when temporarily displaying a help
  521.                                        message.  Increase this if you want more
  522.                                        screen images to be stored in the heap.
  523.                                        Allows you to pop windows on to and off
  524.                                        of each other.
  525.  
  526.       INPUT_FILE_NAME_EXTENSION     -- Three character extension to the input
  527.                                        data file names.  This allows more than
  528.                                        one application of the pre-processor to
  529.                                        exist in the same directory, without
  530.                                        confusing input data files between the
  531.                                        two pre-processors.
  532.  
  533.       TEMPLATE_FILE_NAME_EXTENSION  -- Three character extension to the
  534.                                        template file names.  This allows more
  535.                                        than one application of the pre-
  536.                                        processor to exist in the same
  537.                                        directory, without confusing template
  538.                                        files between the two pre-processors.
  539.  
  540.  
  541. You may need to alter the following procedure for your particular
  542. implementation of the pre-processor:
  543.  
  544.       ProgramPageControl
  545.  
  546.  
  547.  
  548.                                   Page 31
  549.  
  550.  
  551.  
  552.  
  553. H. MENU SUBPROGRAM "Menu.Inc"
  554.  
  555. You may need to alter the following procedures for your particular
  556. implementation of the pre-processor:
  557.  
  558.       DrawMenuPagesModule
  559.       Escape
  560.       PageUp
  561.       PageDown
  562.       ProgramControl
  563.       MenuControl
  564.  
  565.  
  566. I. SCREEN SUBPROGRAM "Screen.Inc"
  567.  
  568.       No changes required
  569.  
  570.  
  571. J. SCROLLING INPUT SUBPROGRAMS "S_Input1.Inc" & "S_Input2.Inc"
  572.  
  573. You may need to alter the following constants for your particular
  574. implementation of the pre-processor:
  575.  
  576.       S_I_ENTRY_LIMIT               -- The maximum number of input data rows
  577.                                        that can be accessed in the scrolling
  578.                                        window.  Note that this is not the
  579.                                        number of data rows displayed in the
  580.                                        scroll window at one time.
  581.  
  582.       TOP_EDGE_OF_OUTER_SCROLL_WINDOW -- Top physical screen row of the outer
  583.                                        window used in scrolling input data up,
  584.                                        down, left, and right.  This value can
  585.                                        range from 1 to 24.  This is the actual
  586.                                        top row (or edge) of the scroll window.
  587.  
  588.       BOTTOM_EDGE_OF_OUTER_SCROLL_WINDOW -- Bottom physical screen row of the
  589.                                        outer window used in scrolling input
  590.                                        data up, down, left, and right.  This
  591.                                        value can range from 2 to 25.  This is
  592.                                        the actual bottom edge (or row) of the
  593.                                        scroll window.
  594.  
  595.       LEFT_EDGE_OF_OUTER_SCROLL_WINDOW -- Left physical screen row of the outer
  596.                                        window used in scrolling input data up,
  597.                                        down, left, and right.  This is the
  598.                                        actual left edge (or column) of the
  599.                                        scroll window.
  600.  
  601.  
  602.  
  603.                                   Page 32
  604.  
  605.  
  606.  
  607.  
  608.       TOP_EDGE_OF_INNER_SCROLL_WINDOW -- Top physical screen row of the inner
  609.                                        window used in scrolling input data up,
  610.                                        down, left, and right.  This value can
  611.                                        range from 1 to 24.  This is the actual
  612.                                        top row that the input data is displayed
  613.                                        in.
  614.  
  615.       BOTTOM_EDGE_OF_INNER_SCROLL_WINDOW -- Bottom physical screen row of the
  616.                                        inner window used in scrolling input
  617.                                        data up, down, left, and right.  This
  618.                                        value can range from 2 to 25.  This is
  619.                                        the actual bottom row that the input
  620.                                        data is displayed in.
  621.  
  622.       LEFT_EDGE_OF_INNER_SCROLL_WINDOW -- Left physical screen row of the inner
  623.                                        window used in scrolling input data up,
  624.                                        down, left, and right.  This is the
  625.                                        actual leftmost column that the input
  626.                                        data is displayed in.
  627.  
  628.       MAX_LEFT_COL                  -- Leftmost input data column that the
  629.                                        scrolling window can access and display.
  630.                                        This value is normally 1.
  631.  
  632.       MAX_NUM_OF_S_I_PROMPT_COLS    -- Maximum number of column prompts (or
  633.                                        headings) in the scrolling window.
  634.                                        Usually this number is found to be
  635.                                        MaxRightCol-MAX_LEFT_COL+1.
  636.  
  637.       MAX_NUM_OF_S_I_DATA_COLS      -- Maximum number of columns in the input
  638.                                        data array.  Usually this number is
  639.                                        found to be MaxRightCol-MAX_LEFT_COL,
  640.                                        or one less than
  641.                                        MAX_NUM_OF_S_I_PROMPT_COL since the
  642.                                        first column of the scroll window is
  643.                                        usually an index column.
  644.  
  645. You may need to alter the following procedures for your particular
  646. implementation of the pre-processor:
  647.  
  648.       RightEdgeOfOuterScrollWindow
  649.       RightEdgeOfInnerScrollWindow
  650.       MaxRightCol
  651.       HighlightSpecial_S_I_Prompts
  652.       Draw_S_I_PagesModule
  653.       Special_S_I_CharEntryModule
  654.       Escape
  655.       PageUp
  656.       PageDown
  657.  
  658.  
  659.  
  660.                                   Page 33
  661.  
  662.  
  663.  
  664.  
  665. XIV. MISCELLANEOUS NOTES
  666.  
  667.  
  668. All data entered by the user is stored as strings.  This allows entries to be
  669. easily manipulated by the user and the pre-processor, also allowing the data to
  670. be easily error checked as it is entered.
  671.  
  672. The input pre-processor is designed so that the user can store his input data
  673. in a work file so that he can later return to it and alter it.  You may or may
  674. not want to include this feature.
  675.  
  676. Screen pages are read from screen page files and are stored in the heap until
  677. they need to be displayed.  This method of displaying screens provides very
  678. rapid screen display for a particular input page, making your application
  679. program appear very professional.  A video retrace check is included in all
  680. rapid screen routines to prevent colored snow from appearing on standard color
  681. monitors.
  682.  
  683. The user is not allowed to specify the input data file name extension.  This
  684. was done to simplify the file I/O routines for the user.  That way the user
  685. does not have to guess what files are input files since the program will only
  686. recognize those data files with the proper extension.  The pre-processor will
  687. only read, write, or display input data files with the same file name
  688. extension.
  689.  
  690.  
  691.  
  692.  
  693. XV. FINAL NOTES
  694.  
  695.  
  696. Much more documentation can be found in the specific subprogram files.
  697.  
  698. I hope that you find this input pre-processor toolkit of use for your
  699. program(s).  I welcome any comments and/or improvements that you can make in
  700. regard to this toolkit.
  701.  
  702. Happy programming!!